-100
+105

 public Dictionary reloadDictionaryFromPackage(String packageId, String locale) {
     String cacheKey = buildPackageCacheKey(packageId, locale);
-    invalidateDictionary(cacheKey);
-    return getDictionaryFromPackage(packageId, locale);
+    try {
+        Dictionary fresh = loadDictionaryFromPackage(packageId, locale);
+        dictionaries.put(cacheKey, fresh);
+        logger.info("Reloaded hunspell dictionary for package [{}] locale [{}]", packageId, locale);
+        return fresh;
+    } catch (Exception e) {
+        throw new IllegalStateException(
+            String.format(Locale.ROOT, "Failed to reload hunspell dictionary for package [%s] locale [%s]", packageId, locale),
+            e
+        );
+    }
 }

 public int invalidateDictionariesByPackage(String packageId) {
-    ...
+    if (Strings.isNullOrEmpty(packageId)) {
+        logger.warn("Cannot invalidate dictionaries: packageId is null or empty");
+        return 0;
+    }
+
     String prefix = packageId + CACHE_KEY_SEPARATOR;
-    int sizeBefore = dictionaries.size();
-    dictionaries.keySet().removeIf(key -> key.startsWith(prefix));
-    int count = sizeBefore - dictionaries.size();
+    java.util.concurrent.atomic.AtomicInteger count = new java.util.concurrent.atomic.AtomicInteger(0);
+    dictionaries.keySet().removeIf(key -> {
+        if (key.startsWith(prefix)) {
+            count.incrementAndGet();
+            return true;
+        }
+        return false;
+    });
+    int removed = count.get();
+    if (removed > 0) {
+        logger.info("Invalidated {} hunspell dictionary cache entries for package: {}", removed, packageId);
+    } else {
+        logger.debug("No cached dictionaries found for package: {}", packageId);
+    }
+    return removed;
+}

 if (hunspellService != null) {
     bind(HunspellService.class).toInstance(hunspellService);
 } else {
-    logger.warn("HunspellService is null; hunspell cache management APIs will not be functional");
+    throw new IllegalStateException(
+        "HunspellService is null; hunspell cache management APIs cannot be initialized. " +
+        "Ensure AnalysisModule is properly configured."
+    );
 }

 if (request.path().endsWith("/_invalidate_all")) {
     invalidateRequest.setInvalidateAll(true);
 } else {
     String packageId = request.param("package_id");
     String locale = request.param("locale");
     String cacheKey = request.param("cache_key");
 
     invalidateRequest.setPackageId(packageId);
     invalidateRequest.setLocale(locale);
     invalidateRequest.setCacheKey(cacheKey);
 }
 
+ActionRequestValidationException validationException = invalidateRequest.validate();
+if (validationException != null) {
+    throw new IllegalArgumentException(validationException.getMessage());
+}
+

-// we only ported this down to the 7.x branch.
-if (version.onOrAfter("7.10.0") && (name.endsWith("zip") || name.endsWith("tar"))) {
-    this.expandedDistDir = new File(checkoutDir, baseDir + "/" + name + "/build/install");
+if (name.endsWith("zip") || name.endsWith("tar")) {
+    if (expectedVersion.onOrAfter("7.10.0")) {
+        this.expandedDistDir = new File(checkoutDir, baseDir + "/" + name + "/build/install");
+    } else {
+        this.expandedDistDir = null;
+    }
+} else {
+    this.expandedDistDir = null;
 }

 ring.stream()
-    .filter(message -> !message.contains("ERROR") && !message.contains("WARN"))
+    .filter(message -> {
+        String normalized = normalizeLogLine(message);
+        return errorsAndWarnings.keySet().stream().noneMatch(lm -> lm.normalizedMessage().equals(normalized));
+    })
     .forEach(message -> LOGGER.lifecycle("» " + message.replace("\n", "\n»  ")));

 int numVirtualShards = indexMetadata.getNumberOfVirtualShards();
-if (numVirtualShards != -1) {
+if (numVirtualShards > 0) {
     final int hash = Murmur3HashFunction.hash(effectiveRouting) + partitionOffset;
     int vShardId = Math.floorMod(hash, numVirtualShards);
     return VirtualShardRoutingHelper.resolvePhysicalShardId(indexMetadata, vShardId);
 }

-return dictionaries.computeIfAbsent(cacheKey, (key) -> {
-    try {
-        return loadDictionaryFromPackage(packageId, locale);
-    } catch (Exception e) {
+Dictionary existing = dictionaries.get(cacheKey);
+if (existing != null) {
+    return existing;
+}
+try {
+    Dictionary loaded = loadDictionaryFromPackage(packageId, locale);
+    Dictionary prev = dictionaries.putIfAbsent(cacheKey, loaded);
+    return prev != null ? prev : loaded;
+} catch (Exception e) {
+    throw new IllegalStateException(
+        String.format(Locale.ROOT, "Failed to load hunspell dictionary for package [%s] locale [%s]", packageId, locale),
+        e
+    );
+}
 
-        throw new IllegalStateException(
-            String.format(Locale.ROOT, "Failed to load hunspell dictionary for package [%s] locale [%s]", packageId, locale),
-            e
-        );
-    }
-});
-

 @Override
 protected void doExecute(Task task, HunspellCacheInvalidateRequest request, ActionListener<HunspellCacheInvalidateResponse> listener) {
+    ActionRequestValidationException validationException = request.validate();
+    if (validationException != null) {
+        listener.onFailure(validationException);
+        return;
+    }
     try {
         ...
     } catch (Exception e) {
         listener.onFailure(e);
     }
 }

-private static final Pattern SAFE_IDENTIFIER_PATTERN = Pattern.compile("^[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9]$|^[a-zA-Z0-9]$");
+private static final Pattern SAFE_IDENTIFIER_PATTERN = Pattern.compile("^[a-zA-Z0-9][a-zA-Z0-9_-]*(?:\\.[a-zA-Z0-9][a-zA-Z0-9_-]*)*$|^[a-zA-Z0-9]$");

 public PPLResponse(StreamInput in) throws IOException {
     super(in);
     this.columns = in.readStringList();
     int rowCount = in.readVInt();
-    this.rows = new ArrayList<>(rowCount);
+    this.rows = new ArrayList<>();
     for (int i = 0; i < rowCount; i++) {
         int colCount = in.readVInt();
         Object[] row = new Object[colCount];
         for (int j = 0; j < colCount; j++) {
             row[j] = in.readGenericValue();
         }
         rows.add(row);
     }
 }

-public int invalidateDictionariesByPackage(String packageId) {
-    if (Strings.isNullOrEmpty(packageId)) {
-        logger.warn("Cannot invalidate dictionaries: packageId is null or empty");
-        return 0;
+String prefix = packageId + CACHE_KEY_SEPARATOR;
+java.util.concurrent.atomic.AtomicInteger count = new java.util.concurrent.atomic.AtomicInteger(0);
+dictionaries.keySet().removeIf(key -> {
+    if (key.startsWith(prefix)) {
+        count.incrementAndGet();
+        return true;
     }
+    return false;
+});
+int removed = count.get();
+if (removed > 0) {
+    logger.info("Invalidated {} hunspell dictionary cache entries for package: {}", removed, packageId);
+} else {
+    logger.debug("No cached dictionaries found for package: {}", packageId);
+}
+return removed;
 
-    String prefix = packageId + CACHE_KEY_SEPARATOR;
-    int sizeBefore = dictionaries.size();
-    dictionaries.keySet().removeIf(key -> key.startsWith(prefix));
-    int count = sizeBefore - dictionaries.size();
-

 private AbsorbAggregateRule(SqlOperatorTable operatorTable) {
-    super(operand(LogicalAggregate.class, any()), "AbsorbAggregateRule");
+    super(operand(LogicalAggregate.class, operand(OpenSearchBoundaryTableScan.class, any())), "AbsorbAggregateRule");
     this.operatorTable = operatorTable;
 }

-this.invalidatedCount = in.readInt();
+this.invalidatedCount = in.readVInt();

 Set<String> cachedKeys = hunspellService.getCachedDictionaryKeys();
 
 Set<String> packageKeys = new HashSet<>();
 Set<String> localeKeys = new HashSet<>();
 
 for (String key : cachedKeys) {
     if (HunspellService.isPackageCacheKey(key)) {
         packageKeys.add(key);
     } else {
         localeKeys.add(key);
     }
 }
 
+int totalSize = packageKeys.size() + localeKeys.size();
 HunspellCacheInfoResponse response = new HunspellCacheInfoResponse(
-    cachedKeys.size(),
+    totalSize,
     packageKeys.size(),
     localeKeys.size(),
     packageKeys,
     localeKeys
 );

 private Dictionary loadDictionaryFromDirectory(Path dicDir, boolean ignoreCase, String description) throws Exception {
+    // Uses this.env (stored at construction time) for tmpDir
+    Path[] affixFiles = FileSystemUtils.files(dicDir, "*.aff");
     ...
-    try (Directory tmp = new NIOFSDirectory(env.tmpDir())) {
+    try (Directory tmp = new NIOFSDirectory(this.env.tmpDir())) {
         return new Dictionary(tmp, "hunspell", affixStream, dicStreams, ignoreCase);
     }

 public HunspellCacheInvalidateResponse(StreamInput in) throws IOException {
     super(in);
     this.acknowledged = in.readBoolean();
-    this.invalidatedCount = in.readInt();
+    this.invalidatedCount = in.readVInt();
     this.packageId = in.readOptionalString();
     this.locale = in.readOptionalString();
     this.cacheKey = in.readOptionalString();
 }

 if (hunspellService != null) {
     bind(HunspellService.class).toInstance(hunspellService);
 } else {
     logger.warn("HunspellService is null; hunspell cache management APIs will not be functional");
+    // Bind a no-op or throw to prevent injection failure for registered transport actions
+    throw new IllegalStateException("HunspellService must not be null when hunspell cache actions are registered");
 }

 @Override
-public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-    builder.startObject();
-    builder.field("acknowledged", acknowledged);
-    builder.field("invalidated_count", invalidatedCount);
-    builder.field("package_id", packageId);
-    builder.field("locale", locale);
-    builder.field("cache_key", cacheKey);
-    builder.endObject();
-    return builder;
+public void writeTo(StreamOutput out) throws IOException {
+    out.writeBoolean(acknowledged);
+    out.writeVInt(invalidatedCount);
+    out.writeOptionalString(packageId);
+    out.writeOptionalString(locale);
+    out.writeOptionalString(cacheKey);
 }

 public int invalidateDictionariesByPackage(String packageId) {
     if (Strings.isNullOrEmpty(packageId)) {
         logger.warn("Cannot invalidate dictionaries: packageId is null or empty");
         return 0;
     }
 
     String prefix = packageId + CACHE_KEY_SEPARATOR;
-    int sizeBefore = dictionaries.size();
-    dictionaries.keySet().removeIf(key -> key.startsWith(prefix));
-    int count = sizeBefore - dictionaries.size();
-    ...
+    java.util.concurrent.atomic.AtomicInteger count = new java.util.concurrent.atomic.AtomicInteger(0);
+    dictionaries.keySet().removeIf(key -> {
+        if (key.startsWith(prefix)) {
+            count.incrementAndGet();
+            return true;
+        }
+        return false;
+    });
+
+    int removed = count.get();
+    if (removed > 0) {
+        logger.info("Invalidated {} hunspell dictionary cache entries for package: {}", removed, packageId);
+    } else {
+        logger.debug("No cached dictionaries found for package: {}", packageId);
+    }
+    return removed;
 }

 @Override
 public void writeTo(StreamOutput out) throws IOException {
+    super.writeTo(out);
     out.writeBoolean(acknowledged);
     out.writeInt(invalidatedCount);
     out.writeOptionalString(packageId);
     out.writeOptionalString(locale);
     out.writeOptionalString(cacheKey);
 }

 if (hunspellService != null) {
     bind(HunspellService.class).toInstance(hunspellService);
 } else {
-    logger.warn("HunspellService is null; hunspell cache management APIs will not be functional");
+    throw new IllegalStateException("HunspellService is required for hunspell cache management APIs but was not provided");
 }

 public int invalidateDictionariesByPackage(String packageId) {
     if (Strings.isNullOrEmpty(packageId)) {
         logger.warn("Cannot invalidate dictionaries: packageId is null or empty");
         return 0;
     }
 
     String prefix = packageId + CACHE_KEY_SEPARATOR;
-    int sizeBefore = dictionaries.size();
-    dictionaries.keySet().removeIf(key -> key.startsWith(prefix));
-    int count = sizeBefore - dictionaries.size();
-    ...
+    java.util.concurrent.atomic.AtomicInteger count = new java.util.concurrent.atomic.AtomicInteger(0);
+    dictionaries.keySet().removeIf(key -> {
+        if (key.startsWith(prefix)) {
+            count.incrementAndGet();
+            return true;
+        }
+        return false;
+    });
+    int removed = count.get();
+
+    if (removed > 0) {
+        logger.info("Invalidated {} hunspell dictionary cache entries for package: {}", removed, packageId);
+    } else {
+        logger.debug("No cached dictionaries found for package: {}", packageId);
+    }
+    return removed;
 }

 if (hunspellService != null) {
     bind(HunspellService.class).toInstance(hunspellService);
 } else {
-    logger.warn("HunspellService is null; hunspell cache management APIs will not be functional");
+    throw new IllegalStateException("HunspellService is null; cannot initialize hunspell cache management APIs");
 }

 ring.stream()
-    .filter(message -> !message.contains("ERROR") && !message.contains("WARN"))
+    .filter(message -> {
+        String normalized = normalizeLogLine(message);
+        return errorsAndWarnings.keySet().stream().noneMatch(lm -> lm.normalizedMessage().equals(normalized));
+    })
     .forEach(message -> LOGGER.lifecycle("» " + message.replace("\n", "\n»  ")));

 int numVirtualShards = indexMetadata.getNumberOfVirtualShards();
-if (numVirtualShards != -1) {
+if (numVirtualShards > 0) {
     final int hash = Murmur3HashFunction.hash(effectiveRouting) + partitionOffset;
     int vShardId = Math.floorMod(hash, numVirtualShards);
     return VirtualShardRoutingHelper.resolvePhysicalShardId(indexMetadata, vShardId);
 }

-return dictionaries.computeIfAbsent(cacheKey, (key) -> {
-    try {
-        return loadDictionaryFromPackage(packageId, locale);
-    } catch (Exception e) {
+Dictionary cached = dictionaries.get(cacheKey);
+if (cached != null) {
+    return cached;
+}
+try {
+    Dictionary loaded = loadDictionaryFromPackage(packageId, locale);
+    dictionaries.put(cacheKey, loaded);
+    return loaded;
+} catch (Exception e) {
+    throw new IllegalStateException(
+        String.format(Locale.ROOT, "Failed to load hunspell dictionary for package [%s] locale [%s]", packageId, locale),
+        e
+    );
+}
 
-        throw new IllegalStateException(
-            String.format(Locale.ROOT, "Failed to load hunspell dictionary for package [%s] locale [%s]", packageId, locale),
-            e
-        );
-    }
-});
-